home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / gadext.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  18.3 KB  |  847 lines
  1. /* Gadgets II */
  2. #include "multiwindows.h"
  3.  
  4. extern struct ExecBase *SysBase;
  5.  
  6. void NewSize();
  7. void GadgetUp();
  8. void MXResize();
  9. void IntCheck();
  10. void FloatCheck();
  11. void HexCheck();
  12. void GadErr();
  13. void RefreshSGadgets();
  14. void RefreshSGadget();
  15. struct MWGadget *FindKeyGadget();
  16.  
  17. #define TYPE_NAMES 3
  18. UBYTE *TypeNames[]=
  19. {
  20.  "GadTools gadget",
  21.  "Intuition gadget",
  22.  "MultiWindows gadget"
  23.  "?",
  24. };
  25.  
  26. #define GT_NAMES 13
  27. UBYTE *GTNames[]=
  28. {
  29.  "Generic",
  30.  "Button",
  31.  "Check Box",
  32.  "Integer",
  33.  "Listview",
  34.  "Mutual Exclude",
  35.  "Number",
  36.  "Cycle",
  37.  "Palette",
  38.  "Scroller",
  39.  "10",
  40.  "Slider",
  41.  "String",
  42.  "Text",
  43.  "??"
  44. };
  45.  
  46. #define INTUITION_NAMES 0
  47. UBYTE *IntuitionNames[]=
  48. {
  49.  "??"
  50. };
  51.  
  52. #define SPECIAL_NAMES 8
  53. UBYTE *SpecialNames[]=
  54. {
  55.  "Toggle Select",
  56.  "Text",
  57.  "Number",
  58.  "Click Box",
  59.  "Status",
  60.  "Wheel",
  61.  "Select Box",
  62.  "Icon",
  63.  "Image",
  64.  "??"
  65. };
  66.  
  67. UBYTE *Unknown[]={"??"};
  68.  
  69.  
  70. /* ---- Name für Gadget-Typ finden */
  71. UBYTE *FindGTypeName(type)
  72.  UWORD type;
  73. {
  74.  
  75.  if(type>TYPE_NAMES) type=TYPE_NAMES;
  76.  return(GetLStr(1038+type,TypeNames[type]));
  77. }
  78.  
  79. /* ---- Name für Gadget-Art finden */
  80. BYTE *FindGKindName(type,kind)
  81.  UWORD type,kind;
  82. {
  83.  ULONG  id;
  84.  UBYTE *names;
  85.  
  86.  switch(type)
  87.   {
  88.    case MWGAD_GADTOOLS:
  89.      id=1060;
  90.      names=>Names;
  91.      if(kind>GT_NAMES) kind=GT_NAMES;
  92.     break;
  93.    case MWGAD_INTUITION:
  94.      id=1042;
  95.      names=&IntuitionNames;
  96.      if(kind>INTUITION_NAMES) kind=INTUITION_NAMES;
  97.     break;
  98.    case MWGAD_SPECIAL:
  99.      id=1080;
  100.      names=&SpecialNames;
  101.      if(kind>SPECIAL_NAMES) kind=SPECIAL_NAMES;
  102.     break;
  103.    default:
  104.      kind=0;
  105.      id=1041;
  106.      names=&Unknown;
  107.     break;
  108.   }
  109.  
  110.  return(GetLStr(id+kind,names[kind]));
  111. }
  112.  
  113. /* ---- Taste wurde gedrückt (VanillaKey) */
  114. void VanillaKey(we,msg,mm)
  115.  struct WindowEntry  *we;
  116.  struct IntuiMessage *msg;
  117.  struct MultiMessage *mm;
  118. {
  119.  BOOL               shifted;
  120.  UBYTE              low;
  121.  struct MWGadget   *gad;
  122.  struct MWMenuItem *item;
  123.  
  124.  item=FindKeyItem(we,msg->Code,msg->Qualifier,FALSE);
  125.  if(item!=NULL)
  126.   {
  127.    CallItem(we,item);
  128.    mm->Class=MULTI_MENUPICK;
  129.    mm->ObjectID=item->ItemID;
  130.    mm->ObjectAddress=item;
  131.    if(item->MenuItem.Flags & CHECKED) mm->ObjectCode=TRUE;
  132.    return;
  133.   }
  134.  
  135.  gad=FindKeyGadget(we,msg->Code);
  136.  if(gad)
  137.   {
  138.    low=tolower((UBYTE)gad->CommandKey);
  139.    if(low==(UBYTE)msg->Code) shifted=FALSE; else shifted=TRUE;
  140.    CallGadget(we,gad,mm,shifted);
  141.    return;
  142.   }
  143.  
  144.  mm->Class=MULTI_VANILLAKEY;
  145.  mm->ObjectID=(ULONG)msg->Code;
  146.  mm->ObjectCode=msg->Qualifier;
  147.  mm->ObjectAddress=we;
  148. }
  149.  
  150. /* ---- Zeitimpuls von Intuition */
  151. void IntuiTicks(we,msg,mm)
  152.  struct WindowEntry  *we;
  153.  struct IntuiMessage *msg;
  154.  struct MultiMessage *mm;
  155. {
  156.  mm->ObjectAddress=we;
  157.  mm->Class=MULTI_INTUITICKS;
  158.  mm->ObjectID=we->WindowID;
  159.  mm->ObjectData[0]=msg->Seconds;
  160.  mm->ObjectData[1]=msg->Micros;
  161.  GadHelpTimer(we,mm);
  162.  NextPointer(we);
  163. }
  164.  
  165. /* ---- Maus wurde bewegt */
  166. void MouseMove(we,msg,mm)
  167.  struct WindowEntry  *we;
  168.  struct IntuiMessage *msg;
  169.  struct MultiMessage *mm;
  170. {
  171.  struct Gadget   *g;
  172.  struct MWGadget *gad;
  173.  
  174.  if(we->Window!=msg->IAddress)
  175.   {
  176.    g=msg->IAddress;
  177.    gad=g->UserData;
  178.    switch(gad->Type)
  179.     {
  180.      case MWGAD_GADTOOLS:
  181.        mm->ObjectID=gad->GadgetID;
  182.        mm->ObjectAddress=gad;
  183.        mm->ObjectCode=msg->Code;
  184.        mm->Class=MULTI_GADGETMOUSE;
  185.  
  186.        switch(gad->Kind)
  187.         {
  188.          case SCROLLER_KIND:
  189.            gad->TagList[SCROLLER_TOP].ti_Data=msg->Code;
  190.            CallAction(gad);
  191.           break;
  192.          case SLIDER_KIND:
  193.            gad->TagList[SLIDER_LEVEL].ti_Data=msg->Code;
  194.            CallAction(gad);
  195.           break;
  196.         }
  197.       break;
  198.     }
  199.   }
  200.  else
  201.   {
  202.    if((we->FMGadget)&&(we->FMGadget->Gadget->Flags & SELECTED))
  203.     {
  204.      gad=we->FMGadget;
  205.      switch(gad->Kind)
  206.       {
  207.        case WHEEL_KIND:
  208.          WheelHandler(gad,msg,mm);
  209.          CallAction(gad);
  210.         break;
  211.       }
  212.     }
  213.    else
  214.     {
  215.      mm->ObjectID=we->WindowID;
  216.      mm->ObjectAddress=we;
  217.      mm->Class=MULTI_MOUSEMOVE;
  218.      mm->ObjectData[0]=msg->MouseX;
  219.      mm->ObjectData[1]=msg->MouseY;
  220.      GadHelpMouse(we,mm);
  221.     }
  222.   }
  223. }
  224.  
  225. /* ---- Gadget wurde gedrückt */
  226. void GadgetUp(we,msg,mm)
  227.  struct WindowEntry  *we;
  228.  struct IntuiMessage *msg;
  229.  struct MultiMessage *mm;
  230. {
  231.  struct Gadget      *g;
  232.  struct StringInfo  *si;
  233.  struct StringData  *sd;
  234.  struct MWGadget    *gad;
  235.  
  236.  we->FMGadget=NULL;
  237.  g=msg->IAddress;
  238.  gad=g->UserData;
  239.  if(gad==NULL) return;
  240.  
  241.  mm->Class=MULTI_GADGETUP;
  242.  mm->ObjectID=gad->GadgetID;
  243.  mm->ObjectAddress=gad;
  244.  switch(gad->Type)
  245.   {
  246.    case MWGAD_GADTOOLS:
  247.      switch(gad->Kind)
  248.       {
  249.        case BUTTON_KIND:
  250.          if(gad->ExtData==TOGGLE_MAGIC)
  251.           {
  252.            if(gad->Update->Flags & SELECTED)
  253.              gad->TagList[TOGGLE_STATUS].ti_Data=TRUE;
  254.            else
  255.              gad->TagList[TOGGLE_STATUS].ti_Data=FALSE;
  256.           }
  257.         break;
  258.        case CYCLE_KIND:
  259.          gad->TagList[CYCLE_ACTIVE].ti_Data=msg->Code;
  260.          mm->ObjectCode=msg->Code;
  261.         break;
  262.        case SLIDER_KIND:
  263.          gad->TagList[SLIDER_LEVEL].ti_Data=msg->Code;
  264.          mm->ObjectCode=msg->Code;
  265.         break;
  266.        case SCROLLER_KIND:
  267.          gad->TagList[SCROLLER_TOP].ti_Data=msg->Code;
  268.          mm->ObjectCode=msg->Code;
  269.         break;
  270.        case LISTVIEW_KIND:
  271.          gad->TagList[LISTVIEW_SELECTED].ti_Data=msg->Code;
  272.          gad->TagList[LISTVIEW_TOP].ti_Data=msg->Code;
  273.          mm->ObjectCode=msg->Code;
  274.         break;
  275.        case STRING_KIND:
  276.          si=gad->Update->SpecialInfo;
  277.          sd=gad->ExtData;
  278.          strcpy(sd->Buffer,si->Buffer);
  279.          mm->ObjectCode=gad->ExtData;
  280.          switch(sd->SpecialType)
  281.           {
  282.            case SST_HEX:
  283.              HexCheck(we,gad,sd,sd->Special,mm);
  284.             break;
  285.            case SST_FLOAT:
  286.              FloatCheck(we,gad,sd,sd->Special,mm);
  287.             break;
  288.           }
  289.         break;
  290.        case INTEGER_KIND:
  291.          si=gad->Update->SpecialInfo;
  292.          mm->ObjectCode=atol(si->Buffer);
  293.          gad->TagList[INTEGER_INTEGER].ti_Data=mm->ObjectCode;
  294.          IntCheck(we,gad,mm->ObjectCode,gad->ExtData);
  295.         break;
  296.        case CHECKBOX_KIND:
  297.          if(gad->Update->Flags & SELECTED)
  298.            mm->ObjectCode=TRUE;
  299.          else
  300.            mm->ObjectCode=FALSE;
  301.          gad->TagList[CHECKBOX_CHECKED].ti_Data=mm->ObjectCode;
  302.         break;
  303.        case PALETTE_KIND:
  304.          gad->TagList[PALETTE_COLOR].ti_Data=msg->Code;
  305.          mm->ObjectCode=msg->Code;
  306.         break;
  307.       }
  308.     break;
  309.    case MWGAD_SPECIAL:
  310.      switch(gad->Kind)
  311.       {
  312.         case WHEEL_KIND:
  313.          WheelHandler(gad,msg,mm);
  314.         break;
  315.       }
  316.     break;
  317.   }
  318.  if(gad->Action) CallAction(gad);
  319. }
  320.  
  321. /* ---- Gadget wird gerade gedrückt */
  322. void GadgetDown(we,msg,mm)
  323.  struct WindowEntry  *we;
  324.  struct IntuiMessage *msg;
  325.  struct MultiMessage *mm;
  326. {
  327.  struct Gadget   *g;
  328.  struct MWGadget *gad;
  329.  
  330.  g=msg->IAddress;
  331.  gad=g->UserData;
  332.  if(gad==NULL) return;
  333.  
  334.  mm->Class=MULTI_GADGETDOWN;
  335.  mm->ObjectID=gad->GadgetID;
  336.  mm->ObjectAddress=gad;
  337.  switch(gad->Type)
  338.   {
  339.    case MWGAD_GADTOOLS:
  340.      switch(gad->Kind)
  341.       {
  342.        case SLIDER_KIND:
  343.          gad->TagList[SLIDER_LEVEL].ti_Data=msg->Code;
  344.          mm->ObjectCode=msg->Code;
  345.         break;
  346.        case SCROLLER_KIND:
  347.          gad->TagList[SCROLLER_TOP].ti_Data=msg->Code;
  348.          mm->ObjectCode=msg->Code;
  349.         break;
  350.        case MX_KIND:
  351.          gad->TagList[MX_ACTIVE].ti_Data=msg->Code;
  352.          mm->ObjectCode=msg->Code;
  353.         break;
  354.       }
  355.     break;
  356.    case MWGAD_SPECIAL:
  357.      switch(gad->Kind)
  358.       {
  359.        case CLICKBOX_KIND:
  360.          if(g->Flags & SELECTED)
  361.            mm->ObjectCode=TRUE;
  362.          else
  363.            mm->ObjectCode=FALSE;
  364.          gad->TagList[CLICKBOX_STATUS].ti_Data=mm->ObjectCode;
  365.          ShowClickBox(gad);
  366.         break;
  367.        case WHEEL_KIND:
  368.          we->FMGadget=gad;
  369.          WheelHandler(gad,msg,mm);
  370.         break;
  371.        case SELECTBOX_KIND:
  372.          SelectBoxHandler(gad,mm);
  373.         break;
  374.       }
  375.     break;
  376.   }
  377.  if(gad->Action) CallAction(gad);
  378. }
  379.  
  380. /* ---- Context freigeben */
  381. void FreeGList(gad,count)
  382.  struct Gadget *gad;
  383.  UWORD          count;
  384. {
  385.  struct Gadget *g;
  386.  int            i;
  387.  
  388.  g=gad;
  389.  if(count>1)
  390.   {
  391.    for(i=1;i<count;i++)
  392.      g=g->NextGadget;
  393.   }
  394.  g->NextGadget=NULL;
  395.  FreeGadgets(gad);
  396. }
  397.  
  398. /* ---- Textlänge ermitteln */
  399. int TextLen(rp,text)
  400.  struct RastPort *rp;
  401.  UBYTE           *text;
  402. {
  403.  int              len;
  404.  struct TextFont *font;
  405.  
  406.  font=rp->Font;
  407.  SetFont(rp,GetTextFont());
  408.  len=TextLength(rp,text,strlen(text));
  409.  SetFont(rp,font);
  410.  return(len);
  411. }
  412.  
  413. /* ---- Gadget disabled machen */
  414. void DisableGad(g)
  415.  struct Gadget *g;
  416. {
  417.  while(g!=NULL)
  418.   {
  419.    g->Flags |= GADGDISABLED;
  420.    g=g->NextGadget;
  421.   }
  422. }
  423.  
  424. /* ---- Gadget überzeichnen */
  425. void RemGad(we,gad)
  426.  struct WindowEntry *we;
  427.  struct MWGadget    *gad;
  428. {
  429.  struct MXData       *md;
  430.  struct ListviewData *ld;
  431.  struct Gadget       *g;
  432.  struct IntuiText    *it;
  433.  struct TextFont     *font;
  434.  int                  x,y,w,h;
  435.  
  436.  if(gad->Type==MWGAD_GADTOOLS)
  437.   {
  438.    if(gad->Kind==MX_KIND)
  439.     {
  440.      md=gad->ExtData;
  441.      RestoreBackground(we,md->X1,md->Y1,md->X2-md->X1,md->Y2-md->Y1);
  442.     }
  443.    else if(gad->Kind==LISTVIEW_KIND)
  444.     {
  445.      ld=gad->ExtData;
  446.      RestoreBackground(we,ld->X1,ld->Y1,ld->X2-ld->X1,ld->Y2-ld->Y1);
  447.     }
  448.  
  449.    g=gad->Gadget;
  450.    while(g!=NULL)
  451.     {
  452.      it=g->GadgetText;
  453.      if(it)
  454.       {
  455.        w=TextLen(we->RastPort,it->IText);
  456.        font=GetTextFont();
  457.        h=font->tf_YSize;
  458.        x=g->LeftEdge+it->LeftEdge;
  459.        y=g->TopEdge+it->TopEdge;
  460.        RestoreBackground(we,x,y,w,h);
  461.       }
  462.      g=g->NextGadget;
  463.     }
  464.    RestoreBackground(we,gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,gad->NewGadget.ng_Width+1,gad->NewGadget.ng_Height+1);
  465.   }
  466.  else
  467.   {
  468.    if(gad->TextPos[TX_WIDTH]!=0)
  469.     {
  470.      RestoreBackground(we,gad->TextPos[TX_LEFT],gad->TextPos[TX_TOP],
  471.                           gad->TextPos[TX_WIDTH],gad->TextPos[TX_HEIGHT]);
  472.     }
  473.    RestoreBackground(we,gad->NewGadget.ng_LeftEdge,gad->NewGadget.ng_TopEdge,gad->NewGadget.ng_Width,gad->NewGadget.ng_Height);
  474.   }
  475. }
  476.  
  477. /* ---- Textplatzierung aus Flags ermitteln */
  478. ULONG PlaceText(flags,def)
  479.  UWORD flags;
  480.  ULONG def;
  481. {
  482.  if(flags & CGA_LEFT)  def=PLACETEXT_LEFT;
  483.  if(flags & CGA_RIGHT) def=PLACETEXT_RIGHT;
  484.  if(flags & CGA_ABOVE) def=PLACETEXT_ABOVE;
  485.  if(flags & CGA_BELOW) def=PLACETEXT_BELOW;
  486.  if(flags & CGA_IN)    def=PLACETEXT_IN;
  487.  if(flags & CGA_HIGHLABEL) def |= NG_HIGHLABEL;
  488.  return(def);
  489. }
  490.  
  491. /* ---- Integer-Gadget-Werte korrigieren */
  492. void IntCheck(we,gad,num,id)
  493.  struct WindowEntry *we;
  494.  struct MWGadget    *gad;
  495.  LONG                num;
  496.  struct IntegerData *id;
  497. {
  498.  
  499.  if(num<id->Min) num=id->Min;
  500.  if(num>id->Max) num=id->Max;
  501.  gad->TagList[INTEGER_INTEGER].ti_Data=num;
  502.  GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  503. }
  504.  
  505. /* ---- Float-Gadget-Werte korrigieren */
  506. void FloatCheck(we,gad,sd,fd,mm)
  507.  struct WindowEntry  *we;
  508.  struct MWGadget     *gad;
  509.  struct StringData   *sd;
  510.  struct FloatData    *fd;
  511.  struct MultiMessage *mm;
  512. {
  513.  FLOAT num;
  514.  
  515.  num=atof(sd->Buffer);
  516.  if(num<fd->Min) num=fd->Min;
  517.  if(num>fd->Max) num=fd->Max;
  518.  sprintf(sd->Buffer,"%f",num);
  519.  mm->ObjectCode=num;
  520.  GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  521. }
  522.  
  523. /* ---- Hex-Gadget-Werte korrigieren */
  524. void HexCheck(we,gad,sd,hd,mm)
  525.  struct WindowEntry  *we;
  526.  struct MWGadget     *gad;
  527.  struct StringData   *sd;
  528.  struct HexData      *hd;
  529.  struct MultiMessage *mm;
  530. {
  531.  ULONG num;
  532.  
  533.  sscanf("%lx",&num);
  534.  if(num<hd->Min) num=hd->Min;
  535.  if(num>hd->Max) num=hd->Max;
  536.  sprintf(sd->Buffer,"%lx",num);
  537.  GTSetGadgetAttrsA(gad->Update,we->Window,NULL,&gad->TagList);
  538. }
  539.  
  540. /* ---- Zu CommandKey passendes Gadget suchen */
  541. struct MWGadget *FindKeyGadget(we,chr)
  542.  struct WindowEntry *we;
  543.  UBYTE               chr;
  544. {
  545.  struct Node        *node;
  546.  struct MWGadget    *gad;
  547.  struct MXData      *md;
  548.  int                 i;
  549.  
  550.  chr=toupper(chr);
  551.  for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  552.   {
  553.    gad=node;
  554.    if((gad->Type==MWGAD_GADTOOLS)&&(gad->Kind==MX_KIND))
  555.     {
  556.      md=gad->ExtData;
  557.      for(i=0;i<12;i++)
  558.        if(md->CommandKey[i]==chr)
  559.         {
  560.          if(gad->TagList[GADGET_DISABLE].ti_Data==FALSE)
  561.           {
  562.            gad->CommandKey=i;
  563.            return(gad);
  564.           }
  565.         }
  566.     }
  567.    else {
  568.      if((gad->CommandKey==chr)&&(gad->TagList[GADGET_DISABLE].ti_Data==FALSE)) {
  569.        return(gad); }}
  570.   }
  571.  return(NULL);
  572. }
  573.  
  574. /* ---- MX-Gadget-Größe bestimmen */
  575. void MXResize(we,gad)
  576.  struct WindowEntry *we;
  577.  struct MWGadget    *gad;
  578. {
  579.  struct Gadget    *g;
  580.  struct MXData    *md;
  581.  struct IntuiText *it;
  582.  long              i,j;
  583.  
  584.  g=gad->Gadget;
  585.  if(g==NULL) return;
  586.  md=gad->ExtData;
  587.  
  588.  md->X1=g->LeftEdge;
  589.  md->Y1=g->TopEdge;
  590.  md->X2=g->LeftEdge+g->Width;
  591.  md->Y2=g->TopEdge+g->Height;
  592.  
  593.  md->X1=gad->NewGadget.ng_LeftEdge;
  594.  md->Y1=gad->NewGadget.ng_TopEdge;
  595.  while(g!=NULL)
  596.   {
  597.    j=0;
  598.    if(md->X2<g->LeftEdge+g->Width) md->X2=g->LeftEdge+g->Width;
  599.    if(md->Y2<g->TopEdge+g->Height) md->Y2=g->TopEdge+g->Height;
  600.    if(!we->Iconify)
  601.     {
  602.      it=g->GadgetText;
  603.      if(it)
  604.       {
  605.        i=strlen(it->IText);
  606.        j=TextLength(we->RastPort,it->IText,i);
  607.        j+=it->LeftEdge;
  608.       }
  609.     }
  610.    if(md->X2<g->LeftEdge+g->Width+j) md->X2=g->LeftEdge+g->Width+j;
  611.    if(md->Y2<g->TopEdge+g->Height) md->Y2=g->TopEdge+g->Height;
  612.    g=g->NextGadget;
  613.   }
  614.  gad->NewGadget.ng_Width=md->X2-md->X1;
  615.  gad->NewGadget.ng_Height=md->Y2-md->Y1;
  616. }
  617.  
  618. /* ---- LV-Gadget-Größe bestimmen */
  619. void LVResize(we,gad)
  620.  struct WindowEntry *we;
  621.  struct MWGadget    *gad;
  622. {
  623.  struct Gadget       *g;
  624.  struct ListivewData *ld;
  625.  
  626.  g=gad->Gadget;
  627.  if(g==NULL) return;
  628.  ld=gad->ExtData;
  629.  
  630.  ld->X1=g->LeftEdge;
  631.  ld->Y1=g->TopEdge;
  632.  ld->X2=g->LeftEdge+g->Width;
  633.  ld->Y2=g->TopEdge+g->Height;
  634.  
  635.  ld->X1=gad->NewGadget.ng_LeftEdge;
  636.  ld->Y1=gad->NewGadget.ng_TopEdge;
  637.  while(g!=NULL)
  638.   {
  639.    if(ld->X2<g->LeftEdge+g->Width) ld->X2=g->LeftEdge+g->Width;
  640.    if(ld->Y2<g->TopEdge+g->Height) ld->Y2=g->TopEdge+g->Height;
  641.    if(ld->X2<g->LeftEdge+g->Width) ld->X2=g->LeftEdge+g->Width;
  642.    if(ld->Y2<g->TopEdge+g->Height) ld->Y2=g->TopEdge+g->Height;
  643.    g=g->NextGadget;
  644.   }
  645. }
  646.  
  647. /* ---- Gadgets zählen */
  648. UWORD CountGadgets(gad)
  649.  struct Gadget *gad;
  650. {
  651.  UWORD i;
  652.  
  653.  i=0;
  654.  while(gad!=NULL)
  655.   {
  656.    i++;
  657.    gad=gad->NextGadget;
  658.   }
  659.  return(i);
  660. }
  661.  
  662. /* ---- GetGadget()-Fehler */
  663. void GGErr(num,id,ft,fk,gt,gk)
  664.  UBYTE num;
  665.  ULONG id;
  666.  UWORD ft,fk,gt,gk;
  667. {
  668.  UBYTE str[250];
  669.  UBYTE *a,*b,*c,*d,*e;
  670.  
  671.  switch(num)
  672.   {
  673.    case 1:
  674.      a=GetLStr(1010,"Wrong gadget type or kind!");
  675.      b=GetLStr(1013,"Current gadget type");
  676.      c=GetLStr(1014,"Current gadget kind");
  677.      d=GetLStr(1015,"Required gadget type");
  678.      e=GetLStr(1016,"Required gadget kind");
  679.      sprintf(&str,"%s\nGadgetID: %ld\n%s: %s\n%s: %s\n%s: %s\n%s: %s",a,id,
  680.                   b,FindGTypeName(ft),
  681.                   c,FindGKindName(ft,fk),
  682.                   d,FindGTypeName(gt),
  683.                   e,FindGKindName(gt,gk));
  684.     break;
  685.    case 2:
  686.      a=GetLStr(1009,"Wrong GadgetID - gadget not available!");
  687.      sprintf(&str,"%s\nGadgetID: %ld",a,id);
  688.     break;
  689.   }
  690.  ErrorRequest("1011:GetGadget()-Error",&str,"1012:Continue");
  691. }
  692.  
  693. /* ---- Gadget suchen */
  694. struct MWGadget *GetGadget(gadgetID,type,kind)
  695.  ULONG gadgetID;
  696.  UWORD type,kind;
  697. {
  698.  struct Node        *node;
  699.  struct MWGadget    *gad,*found;
  700.  struct WindowEntry *we;
  701.  
  702.  WE;
  703.  if(we==NULL) return(NULL);
  704.  
  705.  found=NULL;
  706.  for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  707.   {
  708.    gad=node;
  709.    if(gad->GadgetID==gadgetID)
  710.     {
  711.      found=gad; break;
  712.     }
  713.   }
  714.  
  715.  if(found)
  716.   {
  717.    if((found->Type==type)&&(found->Kind==kind))
  718.      return(found);
  719.    else
  720.      GGErr(1,found->GadgetID,found->Type,found->Kind,type,kind);
  721.   }
  722.  else
  723.    GGErr(2,gadgetID,0,0,0,0);
  724.  return(NULL);
  725. }
  726.  
  727. /* ---- Gadget-Fehler */
  728. void GadErr(num,def,gad)
  729.  ULONG            num;
  730.  UBYTE           *def;
  731.  struct MWGadget *gad;
  732. {
  733.  UBYTE str[100];
  734.  
  735.  sprintf(&str,"%s\nGadgetID: %ld",GetLStr(num,def),gad->GadgetID);
  736.  ErrorRequest("1021:Gadget Error!",&str,"1012:Continue");
  737.  SetError(MERR_GadgetError);
  738. }
  739.  
  740. /* ---- Fenstergröße wurde geändert */
  741. void NewSize(we)
  742.  struct WindowEntry *we;
  743. {
  744.  struct Node     *node;
  745.  struct MWGadget *gad;
  746.  int              oldW,oldH,newW,newH;
  747.  
  748.  /* ---- Neue Streckungsfaktoren berechnen --------------------------- */
  749.  UpdateFrames(we,TRUE);
  750.  
  751.  we->FactorX=(FLOAT)we->Window->Width/(FLOAT)we->OWidth;
  752.  we->FactorY=(FLOAT)we->Window->Height/(FLOAT)we->OHeight;
  753.  
  754.  oldW=we->InnerWidth+we->InnerLeftEdge;
  755.  oldH=we->InnerHeight+we->InnerTopEdge;
  756.  CalcInnerSize(we);
  757.  newW=we->InnerWidth+we->InnerLeftEdge;
  758.  newH=we->InnerHeight+we->InnerTopEdge;
  759.  if(we->Wallpaper)
  760.   {
  761.    if(oldW<newW)
  762.      RestoreBackground(we,oldW,we->InnerTopEdge,
  763.                           newW-oldW,we->InnerHeight);
  764.  
  765.    if(oldH<newH)
  766.      RestoreBackground(we,we->InnerLeftEdge,oldH,
  767.                           we->InnerWidth,newH-oldH);
  768.   }
  769.  we->Width=we->Window->Width;
  770.  we->Height=we->Window->Height;
  771.  
  772.  /* ---- Hintergrund wiederherstellen und Größe berechnen ------------ */
  773.  for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  774.   {
  775.    gad=node;
  776.  
  777.    RemGad(we,gad);
  778.    gad->NewGadget.ng_LeftEdge=INewX(we,gad->LeftEdge);
  779.    gad->NewGadget.ng_TopEdge=INewY(we,gad->TopEdge);
  780.    gad->NewGadget.ng_Width=INewWidth(we,gad->Width);
  781.    gad->NewGadget.ng_Height=INewHeight(we,gad->Height);
  782.   }
  783.  
  784.  /* ---- Alten Schalter entfernen und wieder einfügen ---------------- */
  785.  for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  786.   {
  787.    gad=node;
  788.    UpdateGadget(gad);
  789.   }
  790.  
  791.  /* ---- Refresh für Schalter und Fenster ---------------------------- */
  792.  if(we->Window->FirstGadget)
  793.    RefreshGList(we->Window->FirstGadget,we->Window,NULL,-1L);
  794.  RefreshSGadgets(we);
  795.  UpdateFrames(we,FALSE);
  796.  
  797.  GTRefreshWindow(we->Window,NULL);
  798.  RefreshWindowFrame(we->Window);
  799. }
  800.  
  801. /* ---- Alle MultiWindows-Gadgets neu zeichnen */
  802. void RefreshSGadgets(we)
  803.  struct WindowEntry *we;
  804. {
  805.  struct Node *node;
  806.  
  807.  for(node=we->GadgetList.lh_Head;node!=&we->GadgetList.lh_Tail;node=node->ln_Succ)
  808.    RefreshSGadget(node);
  809. }
  810.  
  811. /* ---- Ein MultiWindows-Gadget neu zeichnen */
  812. void RefreshSGadget(gad)
  813.  struct MWGadget *gad;
  814. {
  815.  if(gad->Type==MWGAD_SPECIAL)
  816.   {
  817.    switch(gad->Kind)
  818.     {
  819.      case WHEEL_KIND:
  820.        ShowWheel(gad,TRUE);
  821.       break;
  822.      case STEXT_KIND:
  823.        ShowText(gad);
  824.       break;
  825.      case SNUMBER_KIND:
  826.        ShowNumber(gad);
  827.       break;
  828.      case STATUS_KIND:
  829.        ShowStatus(gad);
  830.       break;
  831.      case CLICKBOX_KIND:
  832.        ShowClickBox(gad);
  833.       break;
  834.      case SELECTBOX_KIND:
  835.        ShowSelectBox(gad);
  836.       break;
  837.      case ICON_KIND:
  838.        ShowIcon(gad);
  839.       break;
  840.      case IMAGE_KIND:
  841.        ShowImage(gad);
  842.       break;
  843.     }
  844.   }
  845. }
  846.  
  847.